package com.codeplatform.common;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

/**
 * 统一响应结果类
 * 
 * @author CodePlatform
 * @since 2024-01-01
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
    
    /**
     * 响应码：200-成功，其他-失败
     */
    private Integer code;
    
    /**
     * 响应消息
     */
    private String message;
    
    /**
     * 响应数据
     */
    private T data;
    
    /**
     * 时间戳
     */
    private Long timestamp;
    
    /**
     * 是否成功
     */
    private Boolean success;
    
    /**
     * 构造成功响应
     * 
     * @param data 响应数据
     * @param message 响应消息
     * @return 成功响应结果
     */
    public static <T> Result<T> success(T data, String message) {
        Result<T> result = new Result<>();
        result.setCode(ResultCode.SUCCESS.getCode());
        result.setMessage(message);
        result.setData(data);
        result.setSuccess(true);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
    
    /**
     * 构造成功响应（默认消息）
     * 
     * @param data 响应数据
     * @return 成功响应结果
     */
    public static <T> Result<T> success(T data) {
        return success(data, ResultCode.SUCCESS.getMessage());
    }
    
    /**
     * 构造成功响应（无数据）
     * 
     * @param message 响应消息
     * @return 成功响应结果
     */
    public static <T> Result<T> success(String message) {
        return success(null, message);
    }
    
    /**
     * 构造成功响应（默认）
     * 
     * @return 成功响应结果
     */
    public static <T> Result<T> success() {
        return success(null, ResultCode.SUCCESS.getMessage());
    }
    
    /**
     * 构造失败响应
     * 
     * @param resultCode 响应状态码枚举
     * @param message 响应消息
     * @param data 响应数据
     * @return 失败响应结果
     */
    public static <T> Result<T> error(ResultCode resultCode, String message, T data) {
        Result<T> result = new Result<>();
        result.setCode(resultCode.getCode());
        result.setMessage(message);
        result.setData(data);
        result.setSuccess(false);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
    
    /**
     * 构造失败响应
     * 
     * @param resultCode 响应状态码枚举
     * @param data 响应数据
     * @return 失败响应结果
     */
    public static <T> Result<T> error(ResultCode resultCode, T data) {
        return error(resultCode, resultCode.getMessage(), data);
    }
    
    /**
     * 构造失败响应
     * 
     * @param resultCode 响应状态码枚举
     * @return 失败响应结果
     */
    public static <T> Result<T> error(ResultCode resultCode) {
        return error(resultCode, resultCode.getMessage(), null);
    }
    
    /**
     * 构造失败响应（兼容旧版本）
     * 
     * @param code 状态码
     * @param message 响应消息
     * @param data 响应数据
     * @return 失败响应结果
     */
    public static <T> Result<T> error(Integer code, String message, T data) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        result.setData(data);
        result.setSuccess(false);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
    
    /**
     * 构造失败响应（默认错误码）
     * 
     * @param message 响应消息
     * @param data 响应数据
     * @return 失败响应结果
     */
    public static <T> Result<T> error(String message, T data) {
        return error(ResultCode.INTERNAL_SERVER_ERROR.getCode(), message, data);
    }
    
    /**
     * 构造失败响应（无数据）
     * 
     * @param message 响应消息
     * @return 失败响应结果
     */
    public static <T> Result<T> error(String message) {
        return error(ResultCode.INTERNAL_SERVER_ERROR.getCode(), message, null);
    }
    
    /**
     * 构造失败响应（指定错误码）
     * 
     * @param code 状态码
     * @param message 响应消息
     * @return 失败响应结果
     */
    public static <T> Result<T> error(Integer code, String message) {
        return error(code, message, null);
    }
    
    /**
     * 构造参数错误响应
     * 
     * @param message 错误消息
     * @return 参数错误响应结果
     */
    public static <T> Result<T> badRequest(String message) {
        return error(ResultCode.BAD_REQUEST, message, null);
    }
    
    /**
     * 构造参数错误响应（默认消息）
     * 
     * @return 参数错误响应结果
     */
    public static <T> Result<T> badRequest() {
        return error(ResultCode.BAD_REQUEST);
    }
    
    /**
     * 构造未授权响应
     * 
     * @param message 错误消息
     * @return 未授权响应结果
     */
    public static <T> Result<T> unauthorized(String message) {
        return error(ResultCode.UNAUTHORIZED, message, null);
    }
    
    /**
     * 构造未授权响应（默认消息）
     * 
     * @return 未授权响应结果
     */
    public static <T> Result<T> unauthorized() {
        return error(ResultCode.UNAUTHORIZED);
    }
    
    /**
     * 构造禁止访问响应
     * 
     * @param message 错误消息
     * @return 禁止访问响应结果
     */
    public static <T> Result<T> forbidden(String message) {
        return error(ResultCode.FORBIDDEN, message, null);
    }
    
    /**
     * 构造禁止访问响应（默认消息）
     * 
     * @return 禁止访问响应结果
     */
    public static <T> Result<T> forbidden() {
        return error(ResultCode.FORBIDDEN);
    }
    
    /**
     * 构造资源未找到响应
     * 
     * @param message 错误消息
     * @return 资源未找到响应结果
     */
    public static <T> Result<T> notFound(String message) {
        return error(ResultCode.NOT_FOUND, message, null);
    }
    
    /**
     * 构造资源未找到响应（默认消息）
     * 
     * @return 资源未找到响应结果
     */
    public static <T> Result<T> notFound() {
        return error(ResultCode.NOT_FOUND);
    }
    
    /**
     * 构造服务器内部错误响应
     * 
     * @param message 错误消息
     * @return 服务器内部错误响应结果
     */
    public static <T> Result<T> internalError(String message) {
        return error(ResultCode.INTERNAL_SERVER_ERROR, message, null);
    }
    
    /**
     * 构造服务器内部错误响应（默认消息）
     * 
     * @return 服务器内部错误响应结果
     */
    public static <T> Result<T> internalError() {
        return error(ResultCode.INTERNAL_SERVER_ERROR);
    }
    
    /**
     * 构造业务逻辑错误响应
     * 
     * @param message 错误消息
     * @return 业务逻辑错误响应结果
     */
    public static <T> Result<T> businessError(String message) {
        return error(ResultCode.BUSINESS_ERROR, message, null);
    }
    
    /**
     * 构造业务逻辑错误响应（默认消息）
     * 
     * @return 业务逻辑错误响应结果
     */
    public static <T> Result<T> businessError() {
        return error(ResultCode.BUSINESS_ERROR);
    }
    
    /**
     * 构造数据验证错误响应
     * 
     * @param message 错误消息
     * @return 数据验证错误响应结果
     */
    public static <T> Result<T> validationError(String message) {
        return error(ResultCode.VALIDATION_ERROR, message, null);
    }
    
    /**
     * 构造数据验证错误响应（默认消息）
     * 
     * @return 数据验证错误响应结果
     */
    public static <T> Result<T> validationError() {
        return error(ResultCode.VALIDATION_ERROR);
    }
}